home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 April: Mac OS SDK / Dev.CD Apr 99 SDK1.toast / Development Kits / Interfaces&Libraries / Universal / Interfaces / AIncludes / MacMemory.a < prev    next >
Encoding:
Text File  |  1998-08-17  |  35.1 KB  |  1,477 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        MacMemory.a
  3. ;
  4. ;    Contains:    Memory Manager Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Release:    Universal Interfaces 3.2
  8. ;
  9. ;    Copyright:    © 1985-1998 by Apple Computer, Inc., all rights reserved
  10. ;
  11. ;    Bugs?:        For bug reports, consult the following page on
  12. ;                the World Wide Web:
  13. ;
  14. ;                    http://developer.apple.com/bugreporter/
  15. ;
  16. ;
  17.     IF &TYPE('__MACMEMORY__') = 'UNDEFINED' THEN
  18. __MACMEMORY__ SET 1
  19.  
  20.  
  21.     IF &TYPE('__MACTYPES__') = 'UNDEFINED' THEN
  22.     include 'MacTypes.a'
  23.     ENDIF
  24.     IF &TYPE('__MIXEDMODE__') = 'UNDEFINED' THEN
  25.     include 'MixedMode.a'
  26.     ENDIF
  27.  
  28.  
  29.  
  30. maxSize                            EQU        $00800000            ;Max data block size is 8 megabytes
  31.  
  32. defaultPhysicalEntryCount        EQU        8
  33.  
  34.                                                             ; values returned from the GetPageState function 
  35. kPageInMemory                    EQU        0
  36. kPageOnDisk                        EQU        1
  37. kNotPaged                        EQU        2
  38.  
  39.                                                             ; masks for Zone->heapType field 
  40. k32BitHeap                        EQU        1                    ; valid in all Memory Managers 
  41. kNewStyleHeap                    EQU        2                    ; true if new Heap Manager is present 
  42. kNewDebugHeap                    EQU        4                    ; true if new Heap Manager is running in debug mode on this heap 
  43. ;  Note: The type "Size" moved to Types.h 
  44.  
  45.  
  46. Zone                    RECORD 0
  47. bkLim                     ds.l    1                ; offset: $0 (0)
  48. purgePtr                 ds.l    1                ; offset: $4 (4)
  49. hFstFree                 ds.l    1                ; offset: $8 (8)
  50. zcbFree                     ds.l    1                ; offset: $C (12)
  51. gzProc                     ds.l    1                ; offset: $10 (16)
  52. moreMast                 ds.w    1                ; offset: $14 (20)
  53. flags                     ds.w    1                ; offset: $16 (22)
  54. cntRel                     ds.w    1                ; offset: $18 (24)
  55. maxRel                     ds.w    1                ; offset: $1A (26)
  56. cntNRel                     ds.w    1                ; offset: $1C (28)
  57. heapType                 ds.b    1                ; offset: $1E (30)        ;  previously "maxNRel", now holds flags (e.g. k32BitHeap)
  58. unused                     ds.b    1                ; offset: $1F (31)
  59. cntEmpty                 ds.w    1                ; offset: $20 (32)
  60. cntHandles                 ds.w    1                ; offset: $22 (34)
  61. minCBFree                 ds.l    1                ; offset: $24 (36)
  62. purgeProc                 ds.l    1                ; offset: $28 (40)
  63. sparePtr                 ds.l    1                ; offset: $2C (44)
  64. allocPtr                 ds.l    1                ; offset: $30 (48)
  65. heapData                 ds.w    1                ; offset: $34 (52)
  66. sizeof                     EQU *                    ; size:   $36 (54)
  67.                         ENDR
  68. ; typedef struct Zone *                    THz
  69.  
  70. MemoryBlock                RECORD 0
  71. address                     ds.l    1                ; offset: $0 (0)
  72. count                     ds.l    1                ; offset: $4 (4)
  73. sizeof                     EQU *                    ; size:   $8 (8)
  74.                         ENDR
  75. LogicalToPhysicalTable    RECORD 0
  76. logical                     ds        MemoryBlock        ; offset: $0 (0)
  77. physical                 ds.b    8 * MemoryBlock.sizeof ; offset: $8 (8)
  78. sizeof                     EQU *                    ; size:   $48 (72)
  79.                         ENDR
  80. ; typedef short                         PageState
  81.  
  82. ; typedef short                         StatusRegisterContents
  83.  
  84. ;
  85. ; pascal Ptr GetApplLimit(void)
  86. ;
  87.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  88.         Macro
  89.         _GetApplLimit         &dest=(sp)
  90.             move.l            $0130,&dest
  91.         EndM
  92.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  93.         IMPORT_CFM_FUNCTION GetApplLimit
  94.     ENDIF
  95.  
  96. ;
  97. ; pascal THz SystemZone(void)
  98. ;
  99.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  100.         Macro
  101.         _SystemZone           &dest=(sp)
  102.             move.l            $02A6,&dest
  103.         EndM
  104.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  105.         IMPORT_CFM_FUNCTION SystemZone
  106.     ENDIF
  107.  
  108. ;
  109. ; pascal THz ApplicationZone(void)
  110. ;
  111.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  112.         Macro
  113.         _ApplicationZone      &dest=(sp)
  114.             move.l            $02AA,&dest
  115.         EndM
  116.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  117.         IMPORT_CFM_FUNCTION ApplicationZone
  118.     ENDIF
  119.  
  120. ;
  121. ; pascal Handle GZSaveHnd(void)
  122. ;
  123.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  124.         Macro
  125.         _GZSaveHnd            &dest=(sp)
  126.             move.l            $0328,&dest
  127.         EndM
  128.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  129.         IMPORT_CFM_FUNCTION GZSaveHnd
  130.     ENDIF
  131.  
  132. ;
  133. ; pascal Ptr TopMem(void)
  134. ;
  135.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  136.         Macro
  137.         _TopMem               &dest=(sp)
  138.             move.l            $0108,&dest
  139.         EndM
  140.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  141.         IMPORT_CFM_FUNCTION TopMem
  142.     ENDIF
  143.  
  144. ;
  145. ; pascal OSErr MemError(void)
  146. ;
  147.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  148.         Macro
  149.         _MemError             &dest=(sp)
  150.             move.w            $0220,&dest
  151.         EndM
  152.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  153.         IMPORT_CFM_FUNCTION MemError
  154.     ENDIF
  155.  
  156.  
  157.  
  158. ;
  159. ; pascal THz GetZone(void )
  160. ;
  161.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  162.         ; returns:
  163.         ;    THz             <= A0
  164.         _GetZone:    OPWORD    $A11A
  165.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  166.         IMPORT_CFM_FUNCTION GetZone
  167.     ENDIF
  168.  
  169. ;
  170. ; pascal Handle NewHandle(Size byteCount)
  171. ;
  172.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  173.         ; parameters:
  174.         ;    byteCount       => D0
  175.         ; returns:
  176.         ;    Handle          <= A0
  177.         _NewHandle:    OPWORD    $A122
  178.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  179.         IMPORT_CFM_FUNCTION NewHandle
  180.     ENDIF
  181.  
  182. ;
  183. ; pascal Handle NewHandleSys(Size byteCount)
  184. ;
  185.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  186.         ; parameters:
  187.         ;    byteCount       => D0
  188.         ; returns:
  189.         ;    Handle          <= A0
  190.         _NewHandleSys:    OPWORD    $A522
  191.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  192.         IMPORT_CFM_FUNCTION NewHandleSys
  193.     ENDIF
  194.  
  195. ;
  196. ; pascal Handle NewHandleClear(Size byteCount)
  197. ;
  198.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  199.         ; parameters:
  200.         ;    byteCount       => D0
  201.         ; returns:
  202.         ;    Handle          <= A0
  203.         _NewHandleClear:    OPWORD    $A322
  204.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  205.         IMPORT_CFM_FUNCTION NewHandleClear
  206.     ENDIF
  207.  
  208. ;
  209. ; pascal Handle NewHandleSysClear(Size byteCount)
  210. ;
  211.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  212.         ; parameters:
  213.         ;    byteCount       => D0
  214.         ; returns:
  215.         ;    Handle          <= A0
  216.         _NewHandleSysClear:    OPWORD    $A722
  217.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  218.         IMPORT_CFM_FUNCTION NewHandleSysClear
  219.     ENDIF
  220.  
  221. ;
  222. ; pascal THz HandleZone(Handle h)
  223. ;
  224.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  225.         ; parameters:
  226.         ;    h               => A0
  227.         ; returns:
  228.         ;    THz             <= A0
  229.         _HandleZone:    OPWORD    $A126
  230.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  231.         IMPORT_CFM_FUNCTION HandleZone
  232.     ENDIF
  233.  
  234. ;
  235. ; pascal Handle RecoverHandle(Ptr p)
  236. ;
  237.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  238.         ; parameters:
  239.         ;    p               => A0
  240.         ; returns:
  241.         ;    Handle          <= A0
  242.         _RecoverHandle:    OPWORD    $A128
  243.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  244.         IMPORT_CFM_FUNCTION RecoverHandle
  245.     ENDIF
  246.  
  247. ;
  248. ; pascal Handle RecoverHandleSys(Ptr p)
  249. ;
  250.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  251.         ; parameters:
  252.         ;    p               => A0
  253.         ; returns:
  254.         ;    Handle          <= A0
  255.         _RecoverHandleSys:    OPWORD    $A528
  256.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  257.         IMPORT_CFM_FUNCTION RecoverHandleSys
  258.     ENDIF
  259.  
  260. ;
  261. ; pascal Ptr NewPtr(Size byteCount)
  262. ;
  263.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  264.         ; parameters:
  265.         ;    byteCount       => D0
  266.         ; returns:
  267.         ;    Ptr             <= A0
  268.         _NewPtr:    OPWORD    $A11E
  269.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  270.         IMPORT_CFM_FUNCTION NewPtr
  271.     ENDIF
  272.  
  273. ;
  274. ; pascal Ptr NewPtrSys(Size byteCount)
  275. ;
  276.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  277.         ; parameters:
  278.         ;    byteCount       => D0
  279.         ; returns:
  280.         ;    Ptr             <= A0
  281.         _NewPtrSys:    OPWORD    $A51E
  282.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  283.         IMPORT_CFM_FUNCTION NewPtrSys
  284.     ENDIF
  285.  
  286. ;
  287. ; pascal Ptr NewPtrClear(Size byteCount)
  288. ;
  289.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  290.         ; parameters:
  291.         ;    byteCount       => D0
  292.         ; returns:
  293.         ;    Ptr             <= A0
  294.         _NewPtrClear:    OPWORD    $A31E
  295.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  296.         IMPORT_CFM_FUNCTION NewPtrClear
  297.     ENDIF
  298.  
  299. ;
  300. ; pascal Ptr NewPtrSysClear(Size byteCount)
  301. ;
  302.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  303.         ; parameters:
  304.         ;    byteCount       => D0
  305.         ; returns:
  306.         ;    Ptr             <= A0
  307.         _NewPtrSysClear:    OPWORD    $A71E
  308.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  309.         IMPORT_CFM_FUNCTION NewPtrSysClear
  310.     ENDIF
  311.  
  312. ;
  313. ; pascal THz PtrZone(Ptr p)
  314. ;
  315.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  316.         ; parameters:
  317.         ;    p               => A0
  318.         ; returns:
  319.         ;    THz             <= A0
  320.         _PtrZone:    OPWORD    $A148
  321.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  322.         IMPORT_CFM_FUNCTION PtrZone
  323.     ENDIF
  324.  
  325. ;
  326. ; pascal long MaxBlock(void )
  327. ;
  328.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  329.         ; returns:
  330.         ;    long            <= D0
  331.         _MaxBlock:    OPWORD    $A061
  332.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  333.         IMPORT_CFM_FUNCTION MaxBlock
  334.     ENDIF
  335.  
  336. ;
  337. ; pascal long MaxBlockSys(void )
  338. ;
  339.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  340.         ; returns:
  341.         ;    long            <= D0
  342.         _MaxBlockSys:    OPWORD    $A461
  343.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  344.         IMPORT_CFM_FUNCTION MaxBlockSys
  345.     ENDIF
  346.  
  347. ;
  348. ; pascal long StackSpace(void )
  349. ;
  350.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  351.         ; returns:
  352.         ;    long            <= D0
  353.         _StackSpace:    OPWORD    $A065
  354.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  355.         IMPORT_CFM_FUNCTION StackSpace
  356.     ENDIF
  357.  
  358. ;
  359. ; pascal Handle NewEmptyHandle(void )
  360. ;
  361.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  362.         ; returns:
  363.         ;    Handle          <= A0
  364.         _NewEmptyHandle:    OPWORD    $A166
  365.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  366.         IMPORT_CFM_FUNCTION NewEmptyHandle
  367.     ENDIF
  368.  
  369. ;
  370. ; pascal Handle NewEmptyHandleSys(void )
  371. ;
  372.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  373.         ; returns:
  374.         ;    Handle          <= A0
  375.         _NewEmptyHandleSys:    OPWORD    $A566
  376.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  377.         IMPORT_CFM_FUNCTION NewEmptyHandleSys
  378.     ENDIF
  379.  
  380. ;
  381. ; pascal void HLock(Handle h)
  382. ;
  383.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  384.         ; parameters:
  385.         ;    h               => A0
  386.         _HLock:    OPWORD    $A029
  387.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  388.         IMPORT_CFM_FUNCTION HLock
  389.     ENDIF
  390.  
  391. ;
  392. ; pascal void HUnlock(Handle h)
  393. ;
  394.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  395.         ; parameters:
  396.         ;    h               => A0
  397.         _HUnlock:    OPWORD    $A02A
  398.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  399.         IMPORT_CFM_FUNCTION HUnlock
  400.     ENDIF
  401.  
  402. ;
  403. ; pascal void HPurge(Handle h)
  404. ;
  405.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  406.         ; parameters:
  407.         ;    h               => A0
  408.         _HPurge:    OPWORD    $A049
  409.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  410.         IMPORT_CFM_FUNCTION HPurge
  411.     ENDIF
  412.  
  413. ;
  414. ; pascal void HNoPurge(Handle h)
  415. ;
  416.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  417.         ; parameters:
  418.         ;    h               => A0
  419.         _HNoPurge:    OPWORD    $A04A
  420.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  421.         IMPORT_CFM_FUNCTION HNoPurge
  422.     ENDIF
  423.  
  424. ;
  425. ; pascal void HLockHi(Handle h)
  426. ;
  427.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  428.         ; parameters:
  429.         ;    h               => A0
  430.         Macro
  431.         _HLockHi
  432.             dc.w                $A064
  433.             dc.w                $A029
  434.         EndM
  435.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  436.         IMPORT_CFM_FUNCTION HLockHi
  437.     ENDIF
  438.  
  439. ;
  440. ; pascal Handle TempNewHandle(Size logicalSize, OSErr *resultCode)
  441. ;
  442.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  443.         Macro
  444.         _TempNewHandle
  445.             move.w              #$001D,-(sp)
  446.             dc.w                $A88F
  447.         EndM
  448.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  449.         IMPORT_CFM_FUNCTION TempNewHandle
  450.     ENDIF
  451.  
  452. ;
  453. ; pascal Size TempMaxMem(Size *grow)
  454. ;
  455.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  456.         Macro
  457.         _TempMaxMem
  458.             move.w              #$0015,-(sp)
  459.             dc.w                $A88F
  460.         EndM
  461.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  462.         IMPORT_CFM_FUNCTION TempMaxMem
  463.     ENDIF
  464.  
  465. ;
  466. ; pascal long TempFreeMem(void )
  467. ;
  468.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  469.         Macro
  470.         _TempFreeMem
  471.             move.w              #$0018,-(sp)
  472.             dc.w                $A88F
  473.         EndM
  474.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  475.         IMPORT_CFM_FUNCTION TempFreeMem
  476.     ENDIF
  477.  
  478. ;
  479. ; pascal void InitZone(GrowZoneUPP pgrowZone, short cmoreMasters, void *limitPtr, void *startPtr)
  480. ;
  481.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  482.         _InitZone:    OPWORD    $A019
  483.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  484.         IMPORT_CFM_FUNCTION InitZone
  485.     ENDIF
  486.  
  487. ;
  488. ; pascal void SetZone(THz hz)
  489. ;
  490.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  491.         ; parameters:
  492.         ;    hz              => A0
  493.         _SetZone:    OPWORD    $A01B
  494.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  495.         IMPORT_CFM_FUNCTION SetZone
  496.     ENDIF
  497.  
  498. ;
  499. ; pascal Size CompactMem(Size cbNeeded)
  500. ;
  501.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  502.         ; parameters:
  503.         ;    cbNeeded        => D0
  504.         ; returns:
  505.         ;    Size            <= D0
  506.         _CompactMem:    OPWORD    $A04C
  507.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  508.         IMPORT_CFM_FUNCTION CompactMem
  509.     ENDIF
  510.  
  511. ;
  512. ; pascal Size CompactMemSys(Size cbNeeded)
  513. ;
  514.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  515.         ; parameters:
  516.         ;    cbNeeded        => D0
  517.         ; returns:
  518.         ;    Size            <= D0
  519.         _CompactMemSys:    OPWORD    $A44C
  520.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  521.         IMPORT_CFM_FUNCTION CompactMemSys
  522.     ENDIF
  523.  
  524. ;
  525. ; pascal void PurgeMem(Size cbNeeded)
  526. ;
  527.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  528.         ; parameters:
  529.         ;    cbNeeded        => D0
  530.         _PurgeMem:    OPWORD    $A04D
  531.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  532.         IMPORT_CFM_FUNCTION PurgeMem
  533.     ENDIF
  534.  
  535. ;
  536. ; pascal void PurgeMemSys(Size cbNeeded)
  537. ;
  538.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  539.         ; parameters:
  540.         ;    cbNeeded        => D0
  541.         _PurgeMemSys:    OPWORD    $A44D
  542.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  543.         IMPORT_CFM_FUNCTION PurgeMemSys
  544.     ENDIF
  545.  
  546. ;
  547. ; pascal long FreeMem(void )
  548. ;
  549.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  550.         ; returns:
  551.         ;    long            <= D0
  552.         _FreeMem:    OPWORD    $A01C
  553.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  554.         IMPORT_CFM_FUNCTION FreeMem
  555.     ENDIF
  556.  
  557. ;
  558. ; pascal long FreeMemSys(void )
  559. ;
  560.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  561.         ; returns:
  562.         ;    long            <= D0
  563.         _FreeMemSys:    OPWORD    $A41C
  564.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  565.         IMPORT_CFM_FUNCTION FreeMemSys
  566.     ENDIF
  567.  
  568. ;
  569. ; pascal void ReserveMem(Size cbNeeded)
  570. ;
  571.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  572.         ; parameters:
  573.         ;    cbNeeded        => D0
  574.         _ReserveMem:    OPWORD    $A040
  575.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  576.         IMPORT_CFM_FUNCTION ReserveMem
  577.     ENDIF
  578.  
  579. ;
  580. ; pascal void ReserveMemSys(Size cbNeeded)
  581. ;
  582.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  583.         ; parameters:
  584.         ;    cbNeeded        => D0
  585.         _ReserveMemSys:    OPWORD    $A440
  586.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  587.         IMPORT_CFM_FUNCTION ReserveMemSys
  588.     ENDIF
  589.  
  590. ;
  591. ; pascal Size MaxMem(Size *grow)
  592. ;
  593.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  594.         _MaxMem:    OPWORD    $A11D
  595.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  596.         IMPORT_CFM_FUNCTION MaxMem
  597.     ENDIF
  598.  
  599. ;
  600. ; pascal Size MaxMemSys(Size *grow)
  601. ;
  602.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  603.         _MaxMemSys:    OPWORD    $A51D
  604.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  605.         IMPORT_CFM_FUNCTION MaxMemSys
  606.     ENDIF
  607.  
  608. ;
  609. ; pascal void SetGrowZone(GrowZoneUPP growZone)
  610. ;
  611.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  612.         ; parameters:
  613.         ;    growZone        => A0
  614.         _SetGrowZone:    OPWORD    $A04B
  615.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  616.         IMPORT_CFM_FUNCTION SetGrowZone
  617.     ENDIF
  618.  
  619. ;
  620. ; pascal void MoveHHi(Handle h)
  621. ;
  622.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  623.         ; parameters:
  624.         ;    h               => A0
  625.         _MoveHHi:    OPWORD    $A064
  626.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  627.         IMPORT_CFM_FUNCTION MoveHHi
  628.     ENDIF
  629.  
  630. ;
  631. ; pascal void DisposePtr(Ptr p)
  632. ;
  633.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  634.         ; parameters:
  635.         ;    p               => A0
  636.         _DisposePtr:    OPWORD    $A01F
  637.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  638.         IMPORT_CFM_FUNCTION DisposePtr
  639.     ENDIF
  640.  
  641. ;
  642. ; pascal Size GetPtrSize(Ptr p)
  643. ;
  644.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  645.         _GetPtrSize:    OPWORD    $A021
  646.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  647.         IMPORT_CFM_FUNCTION GetPtrSize
  648.     ENDIF
  649.  
  650. ;
  651. ; pascal void SetPtrSize(Ptr p, Size newSize)
  652. ;
  653.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  654.         ; parameters:
  655.         ;    p               => A0
  656.         ;    newSize         => D0
  657.         _SetPtrSize:    OPWORD    $A020
  658.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  659.         IMPORT_CFM_FUNCTION SetPtrSize
  660.     ENDIF
  661.  
  662. ;
  663. ; pascal void DisposeHandle(Handle h)
  664. ;
  665.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  666.         ; parameters:
  667.         ;    h               => A0
  668.         _DisposeHandle:    OPWORD    $A023
  669.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  670.         IMPORT_CFM_FUNCTION DisposeHandle
  671.     ENDIF
  672.  
  673. ;
  674. ; pascal void SetHandleSize(Handle h, Size newSize)
  675. ;
  676.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  677.         ; parameters:
  678.         ;    h               => A0
  679.         ;    newSize         => D0
  680.         _SetHandleSize:    OPWORD    $A024
  681.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  682.         IMPORT_CFM_FUNCTION SetHandleSize
  683.     ENDIF
  684.  
  685. ;  
  686. ;    NOTE
  687. ;    
  688. ;    GetHandleSize and GetPtrSize are documented in Inside Mac as returning 0 
  689. ;    in case of an error, but the traps actually return an error code in D0.
  690. ;    The glue sets D0 to 0 if an error occured.
  691. ;
  692.  
  693. ;
  694. ; pascal Size GetHandleSize(Handle h)
  695. ;
  696.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  697.         _GetHandleSize:    OPWORD    $A025
  698.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  699.         IMPORT_CFM_FUNCTION GetHandleSize
  700.     ENDIF
  701.  
  702. ;
  703. ; pascal Size InlineGetHandleSize(Handle h)
  704. ;
  705.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  706.         ; parameters:
  707.         ;    h               => A0
  708.         ; returns:
  709.         ;    Size            <= D0
  710.         _InlineGetHandleSize:    OPWORD    $A025
  711.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  712.         IMPORT_CFM_FUNCTION InlineGetHandleSize
  713.     ENDIF
  714.  
  715. ;
  716. ; pascal void ReallocateHandle(Handle h, Size byteCount)
  717. ;
  718.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  719.         ; parameters:
  720.         ;    h               => A0
  721.         ;    byteCount       => D0
  722.         _ReallocateHandle:    OPWORD    $A027
  723.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  724.         IMPORT_CFM_FUNCTION ReallocateHandle
  725.     ENDIF
  726.  
  727. ;
  728. ; pascal void ReallocateHandleSys(Handle h, Size byteCount)
  729. ;
  730.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  731.         ; parameters:
  732.         ;    h               => A0
  733.         ;    byteCount       => D0
  734.         _ReallocateHandleSys:    OPWORD    $A427
  735.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  736.         IMPORT_CFM_FUNCTION ReallocateHandleSys
  737.     ENDIF
  738.  
  739. ;
  740. ; pascal void EmptyHandle(Handle h)
  741. ;
  742.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  743.         ; parameters:
  744.         ;    h               => A0
  745.         _EmptyHandle:    OPWORD    $A02B
  746.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  747.         IMPORT_CFM_FUNCTION EmptyHandle
  748.     ENDIF
  749.  
  750. ;
  751. ; pascal void HSetRBit(Handle h)
  752. ;
  753.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  754.         ; parameters:
  755.         ;    h               => A0
  756.         _HSetRBit:    OPWORD    $A067
  757.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  758.         IMPORT_CFM_FUNCTION HSetRBit
  759.     ENDIF
  760.  
  761. ;
  762. ; pascal void HClrRBit(Handle h)
  763. ;
  764.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  765.         ; parameters:
  766.         ;    h               => A0
  767.         _HClrRBit:    OPWORD    $A068
  768.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  769.         IMPORT_CFM_FUNCTION HClrRBit
  770.     ENDIF
  771.  
  772. ;
  773. ; pascal SInt8 HGetState(Handle h)
  774. ;
  775.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  776.         ; parameters:
  777.         ;    h               => A0
  778.         ; returns:
  779.         ;    SInt8           <= D0
  780.         _HGetState:    OPWORD    $A069
  781.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  782.         IMPORT_CFM_FUNCTION HGetState
  783.     ENDIF
  784.  
  785. ;
  786. ; pascal void HSetState(Handle h, SInt8 flags)
  787. ;
  788.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  789.         ; parameters:
  790.         ;    h               => A0
  791.         ;    flags           => D0
  792.         _HSetState:    OPWORD    $A06A
  793.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  794.         IMPORT_CFM_FUNCTION HSetState
  795.     ENDIF
  796.  
  797. ;
  798. ; pascal void PurgeSpace(long *total, long *contig)
  799. ;
  800.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  801.         _PurgeSpace:    OPWORD    $A162
  802.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  803.         IMPORT_CFM_FUNCTION PurgeSpace
  804.     ENDIF
  805.  
  806. ; 
  807. ;    PurgeSpaceTotal and PurgeSpaceContiguous are currently only implement
  808. ;    on classic 68K.  The are the same as PurgeSpace() but return just
  809. ;    one value (either total space purgable or contiguous space purgable).
  810. ;
  811.  
  812. ;
  813. ; pascal long PurgeSpaceTotal(void )
  814. ;
  815.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  816.         ; returns:
  817.         ;    long            <= A0
  818.         _PurgeSpaceTotal:    OPWORD    $A062
  819.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  820.         IMPORT_CFM_FUNCTION PurgeSpaceTotal
  821.     ENDIF
  822.  
  823. ;
  824. ; pascal long PurgeSpaceContiguous(void )
  825. ;
  826.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  827.         ; returns:
  828.         ;    long            <= D0
  829.         _PurgeSpaceContiguous:    OPWORD    $A062
  830.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  831.         IMPORT_CFM_FUNCTION PurgeSpaceContiguous
  832.     ENDIF
  833.  
  834. ;
  835. ; pascal long PurgeSpaceSysTotal(void )
  836. ;
  837.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  838.         ; returns:
  839.         ;    long            <= A0
  840.         _PurgeSpaceSysTotal:    OPWORD    $A562
  841.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  842.         IMPORT_CFM_FUNCTION PurgeSpaceSysTotal
  843.     ENDIF
  844.  
  845. ;
  846. ; pascal long PurgeSpaceSysContiguous(void )
  847. ;
  848.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  849.         ; returns:
  850.         ;    long            <= D0
  851.         _PurgeSpaceSysContiguous:    OPWORD    $A562
  852.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  853.         IMPORT_CFM_FUNCTION PurgeSpaceSysContiguous
  854.     ENDIF
  855.  
  856.  
  857. ; *****************************************************************************
  858. ;
  859. ;    The routines: 
  860. ;
  861. ;        BlockMoveUncached
  862. ;        BlockMoveDataUncached
  863. ;        BlockZero
  864. ;        BlockZeroUncached
  865. ;    
  866. ;    are intended for developers writing drivers. They do not exist in 
  867. ;    “InterfaceLib.” You must link with “DriverServicesLib” to access them.
  868. ;    
  869. ;    But since BlockMove and BlockMoveData exist in both “InterfaceLib” and
  870. ;    “DriverServicesLib”, you cannot link with both libraries.
  871. ;    
  872. ;****************************************************************************
  873.  
  874. ;
  875. ; pascal void BlockMove(const void *srcPtr, void *destPtr, Size byteCount)
  876. ;
  877.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  878.         ; parameters:
  879.         ;    srcPtr          => A0
  880.         ;    destPtr         => A1
  881.         ;    byteCount       => D0
  882.         _BlockMove:    OPWORD    $A02E
  883.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  884.         IMPORT_CFM_FUNCTION BlockMove
  885.     ENDIF
  886.  
  887. ;
  888. ; pascal void BlockMoveData(const void *srcPtr, void *destPtr, Size byteCount)
  889. ;
  890.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  891.         ; parameters:
  892.         ;    srcPtr          => A0
  893.         ;    destPtr         => A1
  894.         ;    byteCount       => D0
  895.         _BlockMoveData:    OPWORD    $A22E
  896.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  897.         IMPORT_CFM_FUNCTION BlockMoveData
  898.     ENDIF
  899.  
  900. ;
  901. ; extern void BlockMoveUncached(const void *srcPtr, void *destPtr, Size byteCount)
  902. ;
  903.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  904.         IMPORT_CFM_FUNCTION BlockMoveUncached
  905.     ENDIF
  906.  
  907. ;
  908. ; extern void BlockMoveDataUncached(const void *srcPtr, void *destPtr, Size byteCount)
  909. ;
  910.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  911.         IMPORT_CFM_FUNCTION BlockMoveDataUncached
  912.     ENDIF
  913.  
  914. ;
  915. ; extern void BlockZero(void *destPtr, Size byteCount)
  916. ;
  917.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  918.         IMPORT_CFM_FUNCTION BlockZero
  919.     ENDIF
  920.  
  921. ;
  922. ; extern void BlockZeroUncached(void *destPtr, Size byteCount)
  923. ;
  924.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  925.         IMPORT_CFM_FUNCTION BlockZeroUncached
  926.     ENDIF
  927.  
  928.  
  929. ;
  930. ; pascal void MaxApplZone(void )
  931. ;
  932.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  933.         _MaxApplZone:    OPWORD    $A063
  934.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  935.         IMPORT_CFM_FUNCTION MaxApplZone
  936.     ENDIF
  937.  
  938. ;
  939. ; pascal void SetApplBase(void *startPtr)
  940. ;
  941.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  942.         ; parameters:
  943.         ;    startPtr        => A0
  944.         _SetApplBase:    OPWORD    $A057
  945.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  946.         IMPORT_CFM_FUNCTION SetApplBase
  947.     ENDIF
  948.  
  949. ;
  950. ; pascal void MoreMasters(void )
  951. ;
  952.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  953.         _MoreMasters:    OPWORD    $A036
  954.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  955.         IMPORT_CFM_FUNCTION MoreMasters
  956.     ENDIF
  957.  
  958. ;
  959. ; pascal void SetApplLimit(void *zoneLimit)
  960. ;
  961.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  962.         ; parameters:
  963.         ;    zoneLimit       => A0
  964.         _SetApplLimit:    OPWORD    $A02D
  965.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  966.         IMPORT_CFM_FUNCTION SetApplLimit
  967.     ENDIF
  968.  
  969.  
  970.  
  971. ;
  972. ; pascal void InitApplZone(void )
  973. ;
  974.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  975.         _InitApplZone:    OPWORD    $A02C
  976.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  977.         IMPORT_CFM_FUNCTION InitApplZone
  978.     ENDIF
  979.  
  980.  
  981. ;   Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  
  982. ;
  983. ; pascal void TempHLock(Handle h, OSErr *resultCode)
  984. ;
  985.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  986.         Macro
  987.         _TempHLock
  988.             move.w              #$001E,-(sp)
  989.             dc.w                $A88F
  990.         EndM
  991.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  992.         IMPORT_CFM_FUNCTION TempHLock
  993.     ENDIF
  994.  
  995. ;
  996. ; pascal void TempHUnlock(Handle h, OSErr *resultCode)
  997. ;
  998.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  999.         Macro
  1000.         _TempHUnlock
  1001.             move.w              #$001F,-(sp)
  1002.             dc.w                $A88F
  1003.         EndM
  1004.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1005.         IMPORT_CFM_FUNCTION TempHUnlock
  1006.     ENDIF
  1007.  
  1008. ;
  1009. ; pascal void TempDisposeHandle(Handle h, OSErr *resultCode)
  1010. ;
  1011.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1012.         Macro
  1013.         _TempDisposeHandle
  1014.             move.w              #$0020,-(sp)
  1015.             dc.w                $A88F
  1016.         EndM
  1017.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1018.         IMPORT_CFM_FUNCTION TempDisposeHandle
  1019.     ENDIF
  1020.  
  1021. ;
  1022. ; pascal Ptr TempTopMem(void )
  1023. ;
  1024.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1025.         Macro
  1026.         _TempTopMem
  1027.             move.w              #$0016,-(sp)
  1028.             dc.w                $A88F
  1029.         EndM
  1030.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1031.         IMPORT_CFM_FUNCTION TempTopMem
  1032.     ENDIF
  1033.  
  1034. ;
  1035. ; pascal OSErr HoldMemory(void *address, unsigned long count)
  1036. ;
  1037.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1038.         ; parameters:
  1039.         ;    address         => A0
  1040.         ;    count           => A1
  1041.         ; returns:
  1042.         ;    OSErr           <= D0
  1043.         Macro
  1044.         _HoldMemory
  1045.             moveq               #0,D0
  1046.             dc.w                $A05C
  1047.         EndM
  1048.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1049.         IMPORT_CFM_FUNCTION HoldMemory
  1050.     ENDIF
  1051.  
  1052. ;
  1053. ; pascal OSErr UnholdMemory(void *address, unsigned long count)
  1054. ;
  1055.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1056.         ; parameters:
  1057.         ;    address         => A0
  1058.         ;    count           => A1
  1059.         ; returns:
  1060.         ;    OSErr           <= D0
  1061.         Macro
  1062.         _UnholdMemory
  1063.             moveq               #1,D0
  1064.             dc.w                $A05C
  1065.         EndM
  1066.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1067.         IMPORT_CFM_FUNCTION UnholdMemory
  1068.     ENDIF
  1069.  
  1070. ;
  1071. ; pascal OSErr LockMemory(void *address, unsigned long count)
  1072. ;
  1073.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1074.         ; parameters:
  1075.         ;    address         => A0
  1076.         ;    count           => A1
  1077.         ; returns:
  1078.         ;    OSErr           <= D0
  1079.         Macro
  1080.         _LockMemory
  1081.             moveq               #2,D0
  1082.             dc.w                $A05C
  1083.         EndM
  1084.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1085.         IMPORT_CFM_FUNCTION LockMemory
  1086.     ENDIF
  1087.  
  1088. ;
  1089. ; pascal OSErr LockMemoryForOutput(void *address, unsigned long count)
  1090. ;
  1091.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1092.         ; parameters:
  1093.         ;    address         => A0
  1094.         ;    count           => A1
  1095.         ; returns:
  1096.         ;    OSErr           <= D0
  1097.         Macro
  1098.         _LockMemoryForOutput
  1099.             moveq               #10,D0
  1100.             dc.w                $A05C
  1101.         EndM
  1102.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1103.         IMPORT_CFM_FUNCTION LockMemoryForOutput
  1104.     ENDIF
  1105.  
  1106. ;
  1107. ; pascal OSErr LockMemoryContiguous(void *address, unsigned long count)
  1108. ;
  1109.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1110.         ; parameters:
  1111.         ;    address         => A0
  1112.         ;    count           => A1
  1113.         ; returns:
  1114.         ;    OSErr           <= D0
  1115.         Macro
  1116.         _LockMemoryContiguous
  1117.             moveq               #4,D0
  1118.             dc.w                $A05C
  1119.         EndM
  1120.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1121.         IMPORT_CFM_FUNCTION LockMemoryContiguous
  1122.     ENDIF
  1123.  
  1124. ;
  1125. ; pascal OSErr UnlockMemory(void *address, unsigned long count)
  1126. ;
  1127.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1128.         ; parameters:
  1129.         ;    address         => A0
  1130.         ;    count           => A1
  1131.         ; returns:
  1132.         ;    OSErr           <= D0
  1133.         Macro
  1134.         _UnlockMemory
  1135.             moveq               #3,D0
  1136.             dc.w                $A05C
  1137.         EndM
  1138.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1139.         IMPORT_CFM_FUNCTION UnlockMemory
  1140.     ENDIF
  1141.  
  1142. ;
  1143. ; pascal OSErr MakeMemoryResident(void *address, unsigned long count)
  1144. ;
  1145.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1146.         ; parameters:
  1147.         ;    address         => A0
  1148.         ;    count           => A1
  1149.         ; returns:
  1150.         ;    OSErr           <= D0
  1151.         Macro
  1152.         _MakeMemoryResident
  1153.             moveq               #11,D0
  1154.             dc.w                $A05C
  1155.         EndM
  1156.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1157.         IMPORT_CFM_FUNCTION MakeMemoryResident
  1158.     ENDIF
  1159.  
  1160. ;
  1161. ; pascal OSErr ReleaseMemoryData(void *address, unsigned long count)
  1162. ;
  1163.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1164.         ; parameters:
  1165.         ;    address         => A0
  1166.         ;    count           => A1
  1167.         ; returns:
  1168.         ;    OSErr           <= D0
  1169.         Macro
  1170.         _ReleaseMemoryData
  1171.             moveq               #12,D0
  1172.             dc.w                $A05C
  1173.         EndM
  1174.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1175.         IMPORT_CFM_FUNCTION ReleaseMemoryData
  1176.     ENDIF
  1177.  
  1178. ;
  1179. ; pascal OSErr MakeMemoryNonResident(void *address, unsigned long count)
  1180. ;
  1181.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1182.         ; parameters:
  1183.         ;    address         => A0
  1184.         ;    count           => A1
  1185.         ; returns:
  1186.         ;    OSErr           <= D0
  1187.         Macro
  1188.         _MakeMemoryNonResident
  1189.             moveq               #13,D0
  1190.             dc.w                $A05C
  1191.         EndM
  1192.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1193.         IMPORT_CFM_FUNCTION MakeMemoryNonResident
  1194.     ENDIF
  1195.  
  1196. ;
  1197. ; pascal OSErr FlushMemory(void *address, unsigned long count)
  1198. ;
  1199.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1200.         ; parameters:
  1201.         ;    address         => A0
  1202.         ;    count           => A1
  1203.         ; returns:
  1204.         ;    OSErr           <= D0
  1205.         Macro
  1206.         _FlushMemory
  1207.             moveq               #14,D0
  1208.             dc.w                $A05C
  1209.         EndM
  1210.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1211.         IMPORT_CFM_FUNCTION FlushMemory
  1212.     ENDIF
  1213.  
  1214. ;
  1215. ; pascal OSErr GetPhysical(LogicalToPhysicalTable *addresses, unsigned long *physicalEntryCount)
  1216. ;
  1217.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1218.         Macro
  1219.         _GetPhysical
  1220.             moveq               #5,D0
  1221.             dc.w                $A05C
  1222.         EndM
  1223.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1224.         IMPORT_CFM_FUNCTION GetPhysical
  1225.     ENDIF
  1226.  
  1227. ;
  1228. ; pascal OSErr DeferUserFn(UserFnUPP userFunction, void *argument)
  1229. ;
  1230.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1231.         ; parameters:
  1232.         ;    userFunctionargument=> A0
  1233.         ;    argument        => D0
  1234.         ; returns:
  1235.         ;    OSErr           <= D0
  1236.         _DeferUserFn:    OPWORD    $A08F
  1237.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1238.         IMPORT_CFM_FUNCTION DeferUserFn
  1239.     ENDIF
  1240.  
  1241. ;
  1242. ; pascal long DebuggerGetMax(void )
  1243. ;
  1244.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1245.         ; returns:
  1246.         ;    long            <= D0
  1247.         Macro
  1248.         _DebuggerGetMax
  1249.             moveq               #0,D0
  1250.             dc.w                $A08D
  1251.         EndM
  1252.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1253.         IMPORT_CFM_FUNCTION DebuggerGetMax
  1254.     ENDIF
  1255.  
  1256. ;
  1257. ; pascal void DebuggerEnter(void )
  1258. ;
  1259.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1260.         Macro
  1261.         _DebuggerEnter
  1262.             moveq               #1,D0
  1263.             dc.w                $A08D
  1264.         EndM
  1265.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1266.         IMPORT_CFM_FUNCTION DebuggerEnter
  1267.     ENDIF
  1268.  
  1269. ;
  1270. ; pascal void DebuggerExit(void )
  1271. ;
  1272.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1273.         Macro
  1274.         _DebuggerExit
  1275.             moveq               #2,D0
  1276.             dc.w                $A08D
  1277.         EndM
  1278.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1279.         IMPORT_CFM_FUNCTION DebuggerExit
  1280.     ENDIF
  1281.  
  1282. ;
  1283. ; pascal void DebuggerPoll(void )
  1284. ;
  1285.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1286.         Macro
  1287.         _DebuggerPoll
  1288.             moveq               #3,D0
  1289.             dc.w                $A08D
  1290.         EndM
  1291.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1292.         IMPORT_CFM_FUNCTION DebuggerPoll
  1293.     ENDIF
  1294.  
  1295. ;
  1296. ; pascal PageState GetPageState(const void *address)
  1297. ;
  1298.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1299.         ; parameters:
  1300.         ;    address         => A0
  1301.         ; returns:
  1302.         ;    PageState       <= D0
  1303.         Macro
  1304.         _GetPageState
  1305.             moveq               #4,D0
  1306.             dc.w                $A08D
  1307.         EndM
  1308.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1309.         IMPORT_CFM_FUNCTION GetPageState
  1310.     ENDIF
  1311.  
  1312. ;
  1313. ; pascal Boolean PageFaultFatal(void )
  1314. ;
  1315.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1316.         ; returns:
  1317.         ;    Boolean         <= D0
  1318.         Macro
  1319.         _PageFaultFatal
  1320.             moveq               #5,D0
  1321.             dc.w                $A08D
  1322.         EndM
  1323.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1324.         IMPORT_CFM_FUNCTION PageFaultFatal
  1325.     ENDIF
  1326.  
  1327. ;
  1328. ; pascal OSErr DebuggerLockMemory(void *address, unsigned long count)
  1329. ;
  1330.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1331.         ; parameters:
  1332.         ;    address         => A0
  1333.         ;    count           => A1
  1334.         ; returns:
  1335.         ;    OSErr           <= D0
  1336.         Macro
  1337.         _DebuggerLockMemory
  1338.             moveq               #6,D0
  1339.             dc.w                $A08D
  1340.         EndM
  1341.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1342.         IMPORT_CFM_FUNCTION DebuggerLockMemory
  1343.     ENDIF
  1344.  
  1345. ;
  1346. ; pascal OSErr DebuggerUnlockMemory(void *address, unsigned long count)
  1347. ;
  1348.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1349.         ; parameters:
  1350.         ;    address         => A0
  1351.         ;    count           => A1
  1352.         ; returns:
  1353.         ;    OSErr           <= D0
  1354.         Macro
  1355.         _DebuggerUnlockMemory
  1356.             moveq               #7,D0
  1357.             dc.w                $A08D
  1358.         EndM
  1359.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1360.         IMPORT_CFM_FUNCTION DebuggerUnlockMemory
  1361.     ENDIF
  1362.  
  1363. ;
  1364. ; pascal StatusRegisterContents EnterSupervisorMode(void )
  1365. ;
  1366.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1367.         ; returns:
  1368.         ;    StatusRegisterContents <= D0
  1369.         Macro
  1370.         _EnterSupervisorMode
  1371.             moveq               #8,D0
  1372.             dc.w                $A08D
  1373.         EndM
  1374.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1375.         IMPORT_CFM_FUNCTION EnterSupervisorMode
  1376.     ENDIF
  1377.  
  1378.  
  1379. ;  
  1380. ;    StripAddress and Translate24To32 are traps on classic 68K,
  1381. ;    but macro to the identity function on PowerMacs or other OS's.
  1382. ;
  1383.  
  1384. ;
  1385. ; pascal Ptr StripAddress(void *theAddress)
  1386. ;
  1387.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1388.         ; parameters:
  1389.         ;    theAddress      => D0
  1390.         ; returns:
  1391.         ;    Ptr             <= D0
  1392.         _StripAddress:    OPWORD    $A055
  1393.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1394.         IMPORT_CFM_FUNCTION StripAddress
  1395.     ENDIF
  1396.  
  1397.  
  1398. ;
  1399. ; pascal Ptr Translate24To32(void *addr24)
  1400. ;
  1401.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1402.         ; parameters:
  1403.         ;    addr24          => D0
  1404.         ; returns:
  1405.         ;    Ptr             <= D0
  1406.         _Translate24To32:    OPWORD    $A091
  1407.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1408.         IMPORT_CFM_FUNCTION Translate24To32
  1409.     ENDIF
  1410.  
  1411. ;
  1412. ; pascal OSErr HandToHand(Handle *theHndl)
  1413. ;
  1414.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1415.         _HandToHand:    OPWORD    $A9E1
  1416.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1417.         IMPORT_CFM_FUNCTION HandToHand
  1418.     ENDIF
  1419.  
  1420. ;
  1421. ; pascal OSErr PtrToXHand(const void *srcPtr, Handle dstHndl, long size)
  1422. ;
  1423.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1424.         ; parameters:
  1425.         ;    srcPtr          => A0
  1426.         ;    dstHndl         => A1
  1427.         ;    size            => D0
  1428.         ; returns:
  1429.         ;    OSErr           <= D0
  1430.         _PtrToXHand:    OPWORD    $A9E2
  1431.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1432.         IMPORT_CFM_FUNCTION PtrToXHand
  1433.     ENDIF
  1434.  
  1435. ;
  1436. ; pascal OSErr PtrToHand(const void *srcPtr, Handle *dstHndl, long size)
  1437. ;
  1438.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1439.         _PtrToHand:    OPWORD    $A9E3
  1440.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1441.         IMPORT_CFM_FUNCTION PtrToHand
  1442.     ENDIF
  1443.  
  1444. ;
  1445. ; pascal OSErr HandAndHand(Handle hand1, Handle hand2)
  1446. ;
  1447.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1448.         ; parameters:
  1449.         ;    hand1           => A0
  1450.         ;    hand2           => A1
  1451.         ; returns:
  1452.         ;    OSErr           <= D0
  1453.         _HandAndHand:    OPWORD    $A9E4
  1454.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1455.         IMPORT_CFM_FUNCTION HandAndHand
  1456.     ENDIF
  1457.  
  1458. ;
  1459. ; pascal OSErr PtrAndHand(const void *ptr1, Handle hand2, long size)
  1460. ;
  1461.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  1462.         ; parameters:
  1463.         ;    ptr1            => A0
  1464.         ;    hand2           => A1
  1465.         ;    size            => D0
  1466.         ; returns:
  1467.         ;    OSErr           <= D0
  1468.         _PtrAndHand:    OPWORD    $A9EF
  1469.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1470.         IMPORT_CFM_FUNCTION PtrAndHand
  1471.     ENDIF
  1472.  
  1473.     IF OLDROUTINENAMES THEN
  1474.     ENDIF    ; OLDROUTINENAMES
  1475.     ENDIF ; __MACMEMORY__ 
  1476.  
  1477.